home *** CD-ROM | disk | FTP | other *** search
/ Network PC / Network PC.iso / amiga utilities / communication / bbs / termv4.6 / extras / source / term-source.lha / Traps.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-03-18  |  7.8 KB  |  415 lines
  1. /*
  2. **    Traps.c
  3. **
  4. **    Trap routines
  5. **
  6. **    Copyright © 1990-1996 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. */
  9.  
  10. #ifndef _GLOBAL_H
  11. #include "Global.h"
  12. #endif
  13.  
  14. struct TrapNode *
  15. ChangeTrapNode(struct GenericList *TrapList,struct TrapNode *Current,STRPTR Sequence,STRPTR Command)
  16. {
  17.     struct TrapNode *New;
  18.  
  19.     if(!Sequence)
  20.         Sequence = Current -> Node . ln_Name;
  21.  
  22.     if(!Command)
  23.         Command = Current -> Command;
  24.  
  25.     if(New = CreateTrapNode(Sequence,Command))
  26.     {
  27.         Insert((struct List *)TrapList,(struct Node *)New,(struct Node *)Current);
  28.  
  29.         Remove((struct Node *)Current);
  30.  
  31.         FreeVecPooled(Current);
  32.  
  33.         return(New);
  34.     }
  35.     else
  36.         return(Current);
  37. }
  38.  
  39. struct TrapNode *
  40. CreateTrapNode(STRPTR SequenceBuffer,STRPTR CommandBuffer)
  41. {
  42.     UBYTE         LocalBuffer[256];
  43.     LONG         Len = TranslateString(SequenceBuffer,LocalBuffer);
  44.     struct TrapNode    *Node;
  45.  
  46.     if(Node = (struct TrapNode *)AllocVecPooled(sizeof(struct TrapNode) + strlen(SequenceBuffer) + 1 + Len + strlen(CommandBuffer) + 1,MEMF_ANY))
  47.     {
  48.         STRPTR String;
  49.  
  50.         String = Node -> Node . ln_Name = (STRPTR)(Node + 1);
  51.  
  52.         strcpy(String,SequenceBuffer);
  53.  
  54.         String += strlen(String) + 1;
  55.  
  56.         Node -> Sequence = String;
  57.  
  58.         CopyMem(LocalBuffer,String,Len);
  59.  
  60.         String += Len;
  61.  
  62.         Node -> Command = String;
  63.  
  64.         Node -> SequenceLen = Len;
  65.         Node -> Count = 0;
  66.  
  67.         strcpy(String,CommandBuffer);
  68.     }
  69.  
  70.     return(Node);
  71. }
  72.  
  73.     /* SaveTraps(STRPTR Name):
  74.      *
  75.      *    Save the trap list to a file.
  76.      */
  77.  
  78. BOOL
  79. SaveTraps(STRPTR Name,struct List *TrapList)
  80. {
  81.     struct IFFHandle    *Handle;
  82.     BOOL             Success = FALSE;
  83.     LONG             Error;
  84.  
  85.     if(Handle = (struct IFFHandle *)AllocIFF())
  86.     {
  87.         if(Handle -> iff_Stream = Open(Name,MODE_NEWFILE))
  88.         {
  89.             InitIFFasDOS(Handle);
  90.  
  91.             if(!(Error = OpenIFF(Handle,IFFF_WRITE)))
  92.             {
  93.                 if(!(Error = PushChunk(Handle,ID_TERM,ID_CAT,IFFSIZE_UNKNOWN)))
  94.                 {
  95.                     Success = TRUE;
  96.  
  97.                     if(!(Error = PushChunk(Handle,ID_TERM,ID_FORM,IFFSIZE_UNKNOWN)))
  98.                     {
  99.                         if(!(Error = PushChunk(Handle,0,ID_VERS,IFFSIZE_UNKNOWN)))
  100.                         {
  101.                             struct TermInfo TermInfo;
  102.  
  103.                             TermInfo . Version    = CONFIG_FILE_VERSION;
  104.                             TermInfo . Revision    = CONFIG_FILE_REVISION;
  105.  
  106.                             if(WriteChunkBytes(Handle,&TermInfo,sizeof(struct TermInfo)) == sizeof(struct TermInfo))
  107.                             {
  108.                                 if(Error = PopChunk(Handle))
  109.                                     Success = FALSE;
  110.                             }
  111.                             else
  112.                             {
  113.                                 Error = IoErr();
  114.  
  115.                                 Success = FALSE;
  116.                             }
  117.                         }
  118.                         else
  119.                             Success = FALSE;
  120.  
  121.                         if(Success)
  122.                         {
  123.                             if(!(Error = PushChunk(Handle,0,ID_TRST,sizeof(struct TrapSettings))))
  124.                             {
  125.                                 struct TrapSettings TrapSettings;
  126.  
  127.                                 memset(&TrapSettings,0,sizeof(TrapSettings));
  128.  
  129.                                 TrapSettings . Enabled = WatchTraps;
  130.  
  131.                                 if(WriteChunkBytes(Handle,&TrapSettings,sizeof(struct TrapSettings)) == sizeof(struct TrapSettings))
  132.                                 {
  133.                                     if(Error = PopChunk(Handle))
  134.                                         Success = FALSE;
  135.                                 }
  136.                                 else
  137.                                 {
  138.                                     Success = FALSE;
  139.  
  140.                                     Error = IoErr();
  141.                                 }
  142.                             }
  143.                             else
  144.                                 Success = FALSE;
  145.                         }
  146.  
  147.                         if(Success)
  148.                         {
  149.                             if(Error = PopChunk(Handle))
  150.                                 Success = FALSE;
  151.                         }
  152.                     }
  153.                     else
  154.                         Success = FALSE;
  155.  
  156.                     if(Success)
  157.                     {
  158.                         struct TrapNode *Node;
  159.  
  160.                         Node = (struct TrapNode *)TrapList -> lh_Head;
  161.  
  162.                         while(Success && Node -> Node . ln_Succ)
  163.                         {
  164.                             if(!(Error = PushChunk(Handle,ID_TERM,ID_FORM,IFFSIZE_UNKNOWN)))
  165.                             {
  166.                                 if(!(Error = PushChunk(Handle,0,ID_SEQN,strlen(Node -> Node . ln_Name))))
  167.                                 {
  168.                                     if(WriteChunkBytes(Handle,Node -> Node . ln_Name,strlen(Node -> Node . ln_Name)) != strlen(Node -> Node . ln_Name))
  169.                                     {
  170.                                         Error = IoErr();
  171.  
  172.                                         Success = FALSE;
  173.  
  174.                                         break;
  175.                                     }
  176.                                     else
  177.                                     {
  178.                                         if(Error = PopChunk(Handle))
  179.                                         {
  180.                                             Success = FALSE;
  181.  
  182.                                             break;
  183.                                         }
  184.                                         else
  185.                                         {
  186.                                             if(!(Error = PushChunk(Handle,0,ID_TRAP,strlen(Node -> Command))))
  187.                                             {
  188.                                                 if(WriteChunkBytes(Handle,Node -> Command,strlen(Node -> Command)) != strlen(Node -> Command))
  189.                                                 {
  190.                                                     Error = IoErr();
  191.  
  192.                                                     Success = FALSE;
  193.  
  194.                                                     break;
  195.                                                 }
  196.                                                 else
  197.                                                 {
  198.                                                     if(Error = PopChunk(Handle))
  199.                                                     {
  200.                                                         Success = FALSE;
  201.  
  202.                                                         break;
  203.                                                     }
  204.                                                 }
  205.                                             }
  206.                                         }
  207.                                     }
  208.                                 }
  209.  
  210.                                 if(Success)
  211.                                 {
  212.                                     if(Error = PopChunk(Handle))
  213.                                     {
  214.                                         Success = FALSE;
  215.  
  216.                                         break;
  217.                                     }
  218.                                 }
  219.                             }
  220.  
  221.                             Node = (struct TrapNode *)Node -> Node . ln_Succ;
  222.                         }
  223.                     }
  224.  
  225.                     if(Success)
  226.                     {
  227.                         if(Error = PopChunk(Handle))
  228.                             Success = FALSE;
  229.                     }
  230.                 }
  231.  
  232.                 CloseIFF(Handle);
  233.             }
  234.  
  235.             Close(Handle -> iff_Stream);
  236.         }
  237.         else
  238.             Error = IoErr();
  239.  
  240.         FreeIFF(Handle);
  241.     }
  242.     else
  243.         Error = ERR_NO_MEM;
  244.  
  245.     if(Success)
  246.         AddProtection(Name,FIBF_EXECUTE);
  247.     else
  248.         DeleteFile(Name);
  249.  
  250.     if(Error)
  251.         SetIoErr(Error);
  252.  
  253.     return(Success);
  254. }
  255.  
  256.     /* LoadTraps(STRPTR Name):
  257.      *
  258.      *    Restore the trap list from a file.
  259.      */
  260.  
  261. BOOL
  262. LoadTraps(STRPTR Name,struct GenericList *TrapList)
  263. {
  264.     STATIC ULONG Stops[8] =
  265.     {
  266.         ID_TERM,ID_VERS,
  267.         ID_TERM,ID_SEQN,
  268.         ID_TERM,ID_TRAP,
  269.         ID_TERM,ID_TRST
  270.     };
  271.  
  272.     struct IFFHandle    *Handle;
  273.     BOOL             Success = FALSE;
  274.     struct ContextNode    *Chunk;
  275.     LONG             Error;
  276.     UBYTE             SequenceBuffer[256],
  277.                  CommandBuffer[256];
  278.     struct TrapSettings     TrapSettings;
  279.     BOOL             TrapSettingsFound = FALSE;
  280.  
  281.     if(Handle = AllocIFF())
  282.     {
  283.         if(Handle -> iff_Stream = Open(Name,MODE_OLDFILE))
  284.         {
  285.             InitIFFasDOS(Handle);
  286.  
  287.             if(!(Error = OpenIFF(Handle,IFFF_READ)))
  288.             {
  289.                 if(!(Error = StopChunks(Handle,(LONG *)Stops,4)))
  290.                 {
  291.                     Success = TRUE;
  292.  
  293.                     SequenceBuffer[0] = CommandBuffer[0] = 0;
  294.  
  295.                     while(!ParseIFF(Handle,IFFPARSE_SCAN))
  296.                     {
  297.                         Chunk = CurrentChunk(Handle);
  298.  
  299.                         if(Chunk -> cn_ID == ID_VERS)
  300.                         {
  301.                             struct TermInfo TermInfo;
  302.  
  303.                             if(ReadChunkBytes(Handle,&TermInfo,sizeof(struct TermInfo)) == sizeof(struct TermInfo))
  304.                             {
  305.                                 if((TermInfo . Version > CONFIG_FILE_VERSION) || (TermInfo . Version == CONFIG_FILE_VERSION && TermInfo . Revision > CONFIG_FILE_REVISION) || (TermInfo . Version == 1 && TermInfo . Revision < 6))
  306.                                 {
  307.                                     Error = ERR_OUTDATED;
  308.  
  309.                                     break;
  310.                                 }
  311.                             }
  312.                             else
  313.                             {
  314.                                 Success = FALSE;
  315.  
  316.                                 Error = IoErr();
  317.  
  318.                                 break;
  319.                             }
  320.                         }
  321.  
  322.                         if(Chunk -> cn_ID == ID_TRST)
  323.                         {
  324.                             if(ReadChunkBytes(Handle,&TrapSettings,sizeof(struct TrapSettings)) == sizeof(struct TrapSettings))
  325.                                 TrapSettingsFound = TRUE;
  326.                             else
  327.                             {
  328.                                 Success = FALSE;
  329.  
  330.                                 Error = IoErr();
  331.  
  332.                                 break;
  333.                             }
  334.                         }
  335.  
  336.                         if(Chunk -> cn_ID == ID_SEQN)
  337.                         {
  338.                             if(ReadChunkBytes(Handle,SequenceBuffer,Chunk -> cn_Size) == Chunk -> cn_Size)
  339.                                 SequenceBuffer[Chunk -> cn_Size] = 0;
  340.                             else
  341.                             {
  342.                                 Success = FALSE;
  343.  
  344.                                 Error = IoErr();
  345.  
  346.                                 break;
  347.                             }
  348.                         }
  349.  
  350.                         if(Chunk -> cn_ID == ID_TRAP)
  351.                         {
  352.                             if(ReadChunkBytes(Handle,CommandBuffer,Chunk -> cn_Size) == Chunk -> cn_Size)
  353.                                 CommandBuffer[Chunk -> cn_Size] = 0;
  354.                             else
  355.                             {
  356.                                 Success = FALSE;
  357.  
  358.                                 Error = IoErr();
  359.  
  360.                                 break;
  361.                             }
  362.                         }
  363.  
  364.                         if(Success && SequenceBuffer[0] && CommandBuffer[0])
  365.                         {
  366.                             struct TrapNode *Node;
  367.  
  368.                             if(Node = CreateTrapNode(SequenceBuffer,CommandBuffer))
  369.                             {
  370.                                 AddGenericListNode(TrapList,(struct Node *)Node,ADD_GLIST_BOTTOM);
  371.  
  372.                                 SequenceBuffer[0] = CommandBuffer[0] = 0;
  373.                             }
  374.                             else
  375.                             {
  376.                                 Success = FALSE;
  377.  
  378.                                 Error = ERR_NO_MEM;
  379.  
  380.                                 break;
  381.                             }
  382.                         }
  383.                     }
  384.                 }
  385.  
  386.                 CloseIFF(Handle);
  387.             }
  388.  
  389.             Close(Handle -> iff_Stream);
  390.         }
  391.         else
  392.             Error = IoErr();
  393.  
  394.         FreeIFF(Handle);
  395.     }
  396.     else
  397.         Error = ERR_NO_MEM;
  398.  
  399.     if(Error)
  400.         SetIoErr(Error);
  401.  
  402.     if(Success)
  403.     {
  404.         TrapsChanged = FALSE;
  405.  
  406.         if(TrapSettingsFound)
  407.             WatchTraps = TrapSettings . Enabled;
  408.     }
  409.  
  410.     if(!TrapList -> ListCount && WatchTraps)
  411.         WatchTraps = FALSE;
  412.  
  413.     return(Success);
  414. }
  415.